#include <iostream>
#include <algorithm>


//先完成一个简单的继承链
struct input_iterator_tag{};   //这是最低层的标签，表示最底层的迭代能力
struct random_access_iterator_tag : public input_iterator_tag{};    //表示更强的，随机访问的能力


//这里定义了迭代器的萃取模板
template <class Iterator>
struct iterator_traits{
    typedef typename Iterator::iterator_category iterator_category;
    typedef typename Iterator::value_type   value_type;
    //这里有两个value_type,他们两个有不同的含义，第一个是迭代器内部已经定义的类型名称，第二个是微萃取后的类型定义的别名
    //就是无论Iterator是类类型还是原生指针，最后都可以根据iterator_traits找到
    //正确的元素类型。并且命名为value_type
};


//假如元素类型是原生指针，哪这里就是偏特化版本
template <class T>
struct iterator_traits< T*>{
    typedef random_access_iteratoro_tag iterator_category;
    typedef T value_type;
};




//这里自己定义迭代器类
template <typename T>
class VectorIterator{
    private:
        T* m_ptr;

    public:
        typedef random_access_iterator_tag iterator_category;
        typedef T value_type;
        typedef ptrdiff_t difference_type;
        typedef T* pointer;
        typedef T& reference;


        //构造函数
        explicit VectorIterator(T* ptr = nullptr) : m+ptr(ptr){}

        //解引用操作符重载,模拟stl的解引用操作符
        T& operator*() const {
            return *m_ptr;
        }

        //重载箭头操作符
        T* operitor->(){
            return m_ptr;
        }

        VectorIterator& operator++() { // 前缀++
            ++m_ptr;
            return *this;
        }

        VectorIterator operator++(int) { // 后缀++
            VectorIterator temp = *this;
            ++m_ptr;
            return temp;
        }
        
        //重写比较操作符
        bool operator==(comst VectorIterator& other) const {
            return m_ptr == other.m_ptr;
        }

        bool operator!=(const VectorIterator& other) const {
            return !(*this ==other);
        }

        //随机访问的实现，这也是stl其中的特性,因为这楼里操作的是数组，存储地址是连续的
        //所以需要将+-重载了，以便直接根据偏移量进行访问
        //比如说 ptr+10 直接向后访问十位
        VectorIterator operator+(size_t n) const {
            return VectorIterator(m_ptr + n);
        }

        difference_type operator-(const VectorIterator& other) const {
            return m_ptr - other.m_ptr;
        }

};

//size_t一般用于表示元素的大小或者数组的长度

//这里定义自己的vector类
template <typename T>
class MyVector{
    private:
        T* m_data;
        size_t m_capacity;   //目前容量
        size_t m_size;      //目前元素数量

        
        //内存扩容，当插入元素但内存不够时或者手动调整容器大小时
        //或者初始化或复制操作时
        void reallocate(size_t new_capacity){
            T* new_data = new T[new_capacity];
            if(m_data){
                std::copy(m_data, m_data + m_size, new_data);
                delete[] m_data;
            }     
            m_data = new_data;
            m_capacity = new_capacity;
        }
    public:
        typedef VectorIterator<T> iterator;
        typrdef VectorIterator<const T> const_iterator;
        
        
        typedef typename iterator_traits<iterator>::value_type value_type;
        //iterator_traits 是模板特性类
        //这段就是在从迭代器类型 iterator 中提取它所指向元素的类型
        //并将该类型重命名为 value_type

        //构造
        MyVector(size_t init_capacity = 4):m_data(nullptr),m_capacity(init_capacity),m_size(0)
        {
            m_data = new T[m_capacity];
        }

        ~MyVector(){
            if(m_data) delete[] m_data;
        }

        //迭代器的访问
        iterator begin() {
            return iterator(m_data);
        }
        iterator end(){
            return iterator(m_data + m_size);
        }

        //以上两个是为了实现
        //        std::vector<int> vec = {1, 2, 3};
        //     for (auto it = vector.begin(); it != vector.end(); ++it) {
        //           *it = 100;  // 可以修改元素
        // }

        const_iterator cbegin() const {
            return const_iterator(m_data);
        }
        const_iterator cend() const {
            return const_iterator(m_data + m_size);
        }

        T& operator[](size_t index){
            return m_data[index];
        }

        //尾插
        void push_back(const T& value){
            if(m_size >= m_capacity){
                reallocate(m_capacity * 2);  //这里还原了
            }                               //vector空间不够就翻倍的性质
            m_data[m_size++] = value;
        }

        size_t size() const {
            return m_size;
        }

        size_t capacity() const {
            return m_capacity;
        }

        //检查迭代器的有效性
        bool is_valid(iterator it) const {
            return it >= begin() && it < end();
        }
};


int main() {
    MyVector<int> vec;

    // 填充数据
    for(int i=0; i<5; ++i) {
        vec.push_back(i*10);
    }

    // 使用迭代器遍历（验证萃取机制）
    for(auto it = vec.begin(); it != vec.end(); ++it) {
        std::cout << *it << " ";
    }

    // 类型萃取验证
    static_assert(
        std::is_same<
            iterator_traits<MyVector<int>::iterator>::value_type,
            int
        >::value, 
        "Type trait verification failed"
    );

    return 0;

}
